package com.xoa.service.equipment.impl;

import com.alibaba.fastjson.JSONArray;
import com.xoa.dao.equipment.*;
import com.xoa.model.equipment.*;
import com.xoa.service.equipment.EquipTypeService;
import com.xoa.util.LimsJson;
import com.xoa.util.common.StringUtils;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.util.*;


@Service
public class EquipTypeServiceImpl implements EquipTypeService {

    @Autowired
    private EquipTypeMapper equipTypeMapper;

    @Autowired
    private EquipCapyMapper equipCapyMapper;

    @Autowired
    private EquipmentMapper equipmentMapper;

    @Autowired
    private EquipmentCapysMapper equipmentCapysMapper;

    @Autowired
    private LimsEquipCapyTypeMapper limsEquipCapyTypeMapper;

    /**
    * 创建作者:   庞君
    * 创建日期:   17:19 2019/12/11
    * 方法介绍:   设备类型拖拽事件
     * id:设备类型id,
     * pid:设备类型父级pid
     * sort:排序号
     * mid:拖拽目标id
    * 参数说明:   No such property: code for class: Script1
    * @return     com.xoa.util.LimsJson<com.xoa.model.equipment.EquipType>
    */
    @Override
    public LimsJson<EquipType> changeEquipmentType(Integer id, Integer pid, Integer sort, Integer mid) {
        LimsJson limsJson = new LimsJson();
        List<EquipType> list = new ArrayList<>();
        EquipType equipType=new EquipType();
        try{
            if(mid!=null){
                Integer mSort = equipTypeMapper.MaxSort(mid);//查询最大排序号根据目标Id
                if(mSort==null){                               //如果不存在最大排序号
                    equipType.setId(id);
                    equipType.setEquipTypePid(mid);
                    equipType.setEquipSort(1);
                }
                if(mSort!=null){
                    equipType.setId(id);
                    equipType.setEquipTypePid(mid);
                    equipType.setEquipSort(mSort+1);
                }
                equipTypeMapper.changeSort(equipType);
                List<EquipType> lists = equipTypeMapper.selAllSortByPid(pid);
                for(EquipType e:lists){
                    if(e.getEquipSort()>sort){
                        equipType.setEquipSort(e.getEquipSort()-1);
                        equipType.setId(id);
                        equipTypeMapper.editSortById(equipType);
                    }
                }
                List<EquipType> equips = equipTypeMapper.selList(mid);
                limsJson.setData(equips);
                limsJson.setCode(0);
                limsJson.setMsg("操作成功");
            }else{
                limsJson.setMsg("操作失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return limsJson;
    }

    public LimsJson<EquipType> showAllEquipmentType(HttpServletRequest request, Integer page, Integer pageSize, Boolean userFlag) {
        LimsJson limsJson = new LimsJson(1,"err");

        try {
            List<EquipType> equipTypes = equipTypeMapper.selectAllEquipType();
            if (equipTypes.size()>0){
                for (EquipType equipType:equipTypes){
                   int cont = equipTypeMapper.contChild(equipType.getId());//统计他的下面还有没有子集
                   if(cont>0){//cont》0说明有
                       equipType.setIsLeaf(false);//isleaf=false;
                   }
                }
                limsJson.setCount(equipTypes.size());
                limsJson.setMsg("查询到"+equipTypes.size()+"条数据");
                limsJson.setCode(0);
                limsJson.setData(equipTypes);
            }


        }catch (Exception e){
            e.printStackTrace();
        }

        return limsJson;
    }

    public LimsJson<EquipType> showParentEquipmentType(HttpServletRequest request,String result) {
        LimsJson limsJson = new LimsJson(1,"err");

        try {
            List<EquipType> parentEquipType = equipTypeMapper.selectParentEquipType();
            if(parentEquipType.size()>0){
                for(EquipType equipTypeP:parentEquipType){
                    equipTypeP.setName(equipTypeP.getLabel());
                    int caonParent = equipTypeMapper.contChild(equipTypeP.getId());//统计他的下面还有没有子集
                    if(caonParent>0){
                        //cont》0说明有ziji
                        equipTypeP.setIsLeaf(false);
                    }
                    if(result!=null) {
                        if (equipTypeP.getEquipTypeCode() != null) {
                            if (!equipTypeP.getEquipTypeCode().equals("")) {
                                equipTypeP.setLabel(equipTypeP.getLabel() + "(" + equipTypeP.getEquipTypeCode() + ")");
                            }
                        }
                    }
                }
                limsJson.setCount(parentEquipType.size());
                limsJson.setMsg("查询到"+parentEquipType.size()+"条数据");
                limsJson.setCode(0);
                limsJson.setData(parentEquipType);
            }else {
                limsJson.setCode(0);
                limsJson.setMsg("查询无数据");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return limsJson;
    }

    public LimsJson<EquipType> showChildEquipmentType(HttpServletRequest request, Integer equipTypeId,String result) {
        LimsJson limsJson = new LimsJson(1,"err");
        try {
            List<EquipType> childEquipTypes = equipTypeMapper.selectChildEquipType(equipTypeId);
            if (childEquipTypes.size()>0){
                for(EquipType equipTypeC:childEquipTypes){
                    equipTypeC.setName(equipTypeC.getLabel());
                    int caonParent = equipTypeMapper.contChild(equipTypeC.getId());//统计他的下面还有没有子集
                    if(caonParent>0){
                        //cont》0说明有ziji
                        equipTypeC.setIsLeaf(false);
                    }
                  if(result!=null){
                      if(equipTypeC.getEquipTypeCode()!=null){
                          if(!equipTypeC.getEquipTypeCode().equals("")) {
                              equipTypeC.setLabel(equipTypeC.getLabel() + "(" + equipTypeC.getEquipTypeCode() + ")");
                          }
                      }
                  }
                }
                limsJson.setCount(childEquipTypes.size());
                limsJson.setMsg("查询到"+childEquipTypes.size()+"条数据");
                limsJson.setCode(0);
                limsJson.setData(childEquipTypes);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return limsJson;
    }

    public LimsJson<EquipType> showEquipmentTypeById(HttpServletRequest request, Integer equipTypeId,String typeCode) {
        LimsJson limsJson = new LimsJson(1,"err");

        try {
            EquipType equipType = equipTypeMapper.selectByPrimaryKey(equipTypeId);

            //客户要求设备得某个类型中原有得能力项不要清空，所以在这里返回原有得能力项。
            List  equipCapies = new ArrayList();
            //设备类型中得能力项ids必须不为空，为空直接添加
            if (equipType.getCapyIds()!=null&&!equipType.getCapyIds().equals("")){
                String [] capyId = equipType.getCapyIds().split(",");
                Map map = new HashMap();

                for (int i=0;i<capyId.length;i++){
                    map.put("capyId",Integer.parseInt(capyId[i]));//根据设备能力项类型查询
                    map.put("typeCode",typeCode);
                    EquipCapy equipCapy = equipCapyMapper.selCapyIdAndTypeCode(map);
                    equipCapies.add(equipCapy);
                }
            }

            if(equipType.getId()!=null){
                limsJson.setCount(1);
                limsJson.setData(equipCapies);
                limsJson.setMsg("data中返回得值是设备原来有的能力项，object中返回得值是设备类型");
                limsJson.setCode(0);
                limsJson.setObject(equipType);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        return limsJson;
    }

    public LimsJson<EquipType> addParentEquipmentType(HttpServletRequest request, EquipType equipType) {
        LimsJson limsJson = new LimsJson(1,"err");

        try {
            int i = equipTypeMapper.insertSelective(equipType);

            if(i>0){
                limsJson.setCode(0);
                limsJson.setMsg("添加成功");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return limsJson;
    }

    public LimsJson<EquipType> addChildEquipmentType(HttpServletRequest request, Integer equipTypeId, EquipType equipType) {
        LimsJson limsJson = new LimsJson(1,"err");
        try {
            //获取父亲，使用父亲id作为子类父id
            EquipType parentEquipType = equipTypeMapper.selectByPrimaryKey(equipTypeId);
            //设置父id
            equipType.setEquipTypePid(parentEquipType.getId());
            //插入
            int i = equipTypeMapper.insert(equipType);
            if(i>0){//添加成功
                limsJson.setCode(0);
                limsJson.setCount(i);
                limsJson.setMsg("添加成功");
            }else {//失败
                limsJson.setCount(1);
                limsJson.setMsg("添加失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return limsJson;
    }

    public LimsJson<EquipType> editEquipmentType(HttpServletRequest request, String equipType) {
        LimsJson limsJson = new LimsJson(1,"err");
        JSONObject jsonObject = JSONObject.fromObject(equipType);
        EquipType equipType1 = (EquipType)JSONObject.toBean(jsonObject,EquipType.class);
        try {
            if(equipType1!=null&&equipType1.getId()!=null){
                int i = equipTypeMapper.updateByPrimaryKeySelective(equipType1);
                if(i>0){//修改成功
                    limsJson.setCode(0);
                    limsJson.setMsg("修改成功");
                }else {//失败
                    limsJson.setCode(1);
                    limsJson.setMsg("修改失败");
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            limsJson.setMsg("系统错误");
        }
        return limsJson;
    }

    public LimsJson<EquipType> deleteEquipmentTypeById(HttpServletRequest request, Integer equipTypeId) {
        LimsJson limsJson = new LimsJson(1,"err");
        try {
            //删除之前查询有无使用设备，有设备在使用无法删除该类型
            List<Equipment> equips = equipmentMapper.selectByEquipTypeId(equipTypeId);
            if(equips.size()>0){
                limsJson.setMsg("该类型下有设备，无法删除");
                return limsJson;
            }
            int i= equipTypeMapper.deleteByPrimaryKey(equipTypeId);
            if(i>0){//删除成功
                limsJson.setCode(0);
                limsJson.setMsg("删除成功");
            }else {//失败
                limsJson.setCode(1);
                limsJson.setMsg("删除失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return limsJson;
    }



    public LimsJson<EquipType> deleteArrayEquipmentTypeById(HttpServletRequest request, String equipTypeIds) {
        LimsJson limsJson = new LimsJson(1,"err");
        try {
            String[] idArray = equipTypeIds.split(",");
            for (int i=0;i<idArray.length;i++){
                Integer equipTypeId = Integer.parseInt(idArray[i]);
                int mes = equipTypeMapper.deleteByPrimaryKey(equipTypeId);
                if(mes>0){//删除成功
                    limsJson.setCode(0);
                    limsJson.setMsg("删除成功");
                }else {//失败
                    limsJson.setCode(1);
                    limsJson.setMsg("删除失败");
                }
            }
        }catch (Exception e){//异常
            e.printStackTrace();
        }
        return limsJson;
    }
    //这是一个在设备类型中得一个同步能力值，同步的单词属于敏感单词，用together代替，
    public LimsJson<Object> togetherCapy(HttpServletRequest request,Integer equipTypeId,String equipCapyIds){
        LimsJson limsJson = new LimsJson(1,"err");
        Map map = new HashMap();
        List list = new ArrayList();
        try{
            if(equipTypeId != null && equipTypeId.toString() != ""){
                //设备集
                List<Equipment> equipments = equipmentMapper.selectByEquipTypeId(equipTypeId);
                //处理前端传过来的能力项ids

                String ids="";
                //遍历设备集
                if(equipments!=null&&!equipments.isEmpty()){
                    for (Equipment equipment : equipments){
                        //查询每一台设备的的所有能力项
                        List<EquipmentCapys> capysLimsList = equipmentCapysMapper.selectByEquipId(equipment.getEquipId());
                        //判断是不是第一次添加，不是执行if中代码 是，执行else中代码
                        if(capysLimsList!=null&&capysLimsList.size()>0){//不是
                            //遍历设备的能力项

                            for (EquipmentCapys equipmentCapys : capysLimsList){
                                //这个for是为了在设备能力表i中查询出某个类型下的设备所具有的能力
                                ids+=equipmentCapys.getCapyId()+",";
                            }
                            if(ids!=null&&!ids.equals("")&&equipCapyIds!=null&&!equipCapyIds.equals("")){
                                String[] equipCapyId = equipCapyIds.split(",");//需要同步的设备能力ids
                                String[] id = ids.split(",");//设备能力表中的设备所具有的ids
                                int res=0;
                                int els=0;
                                for(int i=0;i<equipCapyId.length;i++){
                                    if(Arrays.asList(id).contains(equipCapyId[i])==false){
                                        //这标识ji
                                        EquipmentCapys equipmentCapys = new EquipmentCapys();
                                        equipmentCapys.setEquipId(equipment.getEquipId());
                                        equipmentCapys.setCapyId(Integer.parseInt(equipCapyId[i]));
                                        int e =equipmentCapysMapper.insertSelective(equipmentCapys);
                                        if(e>0){
                                            res++;
                                        }
                                    }else {
                                        els++;
                                    }
                                }
                                //判断那些能力项是新增加的
                                for(int j=0;j<id.length;j++){
                                    if(Arrays.asList(equipCapyId).contains(id[j])==false){
                                        //标识设备具有的ids不在需要同步的equipCapyIds中，所以需要删掉
                                        Map map1 = new HashMap();
                                        map1.put("equipId",equipment.getEquipId());
                                        map1.put("capyId",Integer.valueOf(id[j]));
                                        equipmentCapysMapper.deleteByEquipIdAndCapyId(map1);
                                    }
                                }
                                if(res>0){
                                    limsJson.setCode(0);
                                    limsJson.setMsg("同步成功");
                                }
                                if(els==equipCapyId.length){
                                    limsJson.setCode(0);
                                    limsJson.setMsg("该类型下的设备都具有选中能力");
                                }
                            }else{
                                limsJson.setMsg("该类型无能力项");
                            }
                        }else{//是，执行else中代码
                            if(equipCapyIds!=null&&!equipCapyIds.equals("")){
                                int res=0;
                                String[] equipCapyId = equipCapyIds.split(",");
                                for(int i=0;i<equipCapyId.length;i++){
                                    EquipmentCapys equipmentCapys = new EquipmentCapys();
                                    equipmentCapys.setEquipId(equipment.getEquipId());
                                    equipmentCapys.setCapyId(Integer.parseInt(equipCapyId[i]));
                                    int e= equipmentCapysMapper.insert(equipmentCapys);
                                    if(e>0){
                                        res++;
                                    }
                                }
                                if(res==equipCapyId.length){
                                    limsJson.setCode(0);
                                    limsJson.setMsg("同步成功");
                                }
                            }else{
                                limsJson.setMsg("该类型无能力项");
                            }
                        }
                    }
                }else{
                    limsJson.setMsg("该类型下无设备！");
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            limsJson.setMsg("系统错误");
        }
        return limsJson;
    }

    public List<Map<Object,Object>> selectNameAndId(HttpServletRequest request){
        List list = new ArrayList();
        List<EquipType> equipTypeList = equipTypeMapper.selectNameAndId();
        if(equipTypeList!=null&&equipTypeList.size()>0){
            for (EquipType equipType : equipTypeList){
                Map mapkey = new HashMap();
                mapkey.put("key",equipType.getId());
                mapkey.put("value",equipType.getLabel());

                list.add(mapkey);
            }
        }else {
            Map mapkey = new HashMap();
            mapkey.put("keymes","key查询失败");
            mapkey.put("valuemes","value查询失败");
            list.add(mapkey);
        }
        return list;
    }

    public LimsJson changeSort(Integer typeId1 , Integer typeId2){
        LimsJson limsJson = new LimsJson(1,"err");

        //一下处理都是基于下列顺序做的，所以前台穿过类得id顺序也为这个，顺序不可以乱
        EquipType equipType1 = equipTypeMapper.selectByPrimaryKey(typeId1);//需要移动得目标
        EquipType equipType2 = equipTypeMapper.selectByPrimaryKey(typeId2);//移动至某个目标
        Integer start=null;
        Integer end = null;
        if(typeId1>typeId2){
            start=typeId2;
            end = typeId1;
        }else if(typeId1<typeId2){
            start=typeId1;
            end = typeId2;
        }

        //查询equipType2以后得数据
        List<EquipType> list = equipTypeMapper.selectSortEquipType(start,end);
        try {
            if(equipType1.getEquipTypePid().equals(equipType2.getEquipTypePid())){
                if(typeId1<typeId2){
                    equipType1.setEquipSort(equipType2.getEquipSort());
                    for (EquipType equipType : list){
                        if(equipType.getId().equals(equipType2.getId())){
                            continue;
                        }else{
                            equipType.setEquipSort(equipType.getEquipSort()-1);
                        }
                    }
                    limsJson.setData(list);
                    limsJson.setCode(0);
                }else if(typeId1>typeId2){
                    equipType1.setEquipSort(equipType2.getEquipSort()+1);
                    for(EquipType equipType : list){
                        if(equipType.getId().equals(equipType1.getId())||equipType.getId().equals(equipType2.getId())){
                            continue;
                        }else{
                            equipType.setEquipSort(equipType.getEquipSort()+1);
                        }
                    }
                    limsJson.setData(list);
                    limsJson.setCode(0);
                }
            }else {
                equipType1.setEquipTypePid(equipType2.getEquipTypePid());
                if(typeId1<typeId2){
                    equipType1.setEquipSort(equipType2.getEquipSort());
                    for (EquipType equipType : list){
                        if(equipType.getId().equals(equipType2.getId())){
                            continue;
                        }else{
                            equipType.setEquipSort(equipType.getEquipSort()-1);
                        }
                    }
                    limsJson.setData(list);
                    limsJson.setCode(0);
                }else if(typeId1>typeId2){
                    equipType1.setEquipSort(equipType2.getEquipSort()+1);
                    for(EquipType equipType : list){
                        if(equipType.getId().equals(equipType1.getId())||equipType.getId().equals(equipType2.getId())){
                            continue;
                        }else{
                            equipType.setEquipSort(equipType.getEquipSort()+1);
                        }
                    }
                    limsJson.setData(list);
                    limsJson.setCode(0);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return limsJson;
    }

    public LimsJson<Object> addEquipType(HttpServletRequest request,Integer pId,Integer id,
                                         String label,int type,Integer sort){
        LimsJson limsJson = new LimsJson(1 ,"err");
        //业务需求是在新增加的节点需要排序，也就是说后加进来的节点，
        // 只要不是子节点，就需要对其后面的sort都需要进行+1处理
        if(label.indexOf("未命名")==-1) {
            List resultList = new ArrayList();
            if (type == 0) {//添加前叶子节点
                //根据当前节点的sort查询这个sort之后的所有数据（sort不可以重复）
                List<EquipType> list = equipTypeMapper.selectBySort(sort);
                //重装设备类型
                EquipType equipType = new EquipType();
                equipType.setEquipTypePid(pId);
                equipType.setLabel(label);
                equipType.setEquipSort(sort);
                //添加数据
                int i = equipTypeMapper.insertSelective(equipType);
                if (i > 0) {
                    //遍历根据sort查询出来的list
                    for (EquipType e : list) {
                        if (e.getId() != null && e.getEquipSort() != null) {
                            //对遍历出来的每一个类型的sort+1处理
                            e.setEquipSort(e.getEquipSort() + 1);
                        }
                        //更新遍历结果（这是一个最低效率的方法，但是没想到其他方法，只能使用此方法）
                        equipTypeMapper.updateByPrimaryKeySelective(e);
                    }
                    List<EquipType> newList = equipTypeMapper.selectChildEquipType(pId);
                    for (EquipType e : newList) {
                        e.setName(e.getLabel());
                        if (e.getEquipTypeCode() != null) {
                            if (!e.getEquipTypeCode().equals("")) {
                                e.setLabel(e.getLabel() + "(" + e.getEquipTypeCode() + ")");
                            }
                        }
                    }
                    equipType.setName(label);
                    limsJson.setObject(equipType);
                    limsJson.setData(newList);
                    limsJson.setCode(0);
                    limsJson.setMsg("添加成功");
                }

            } else if (type == 1) { //添加自身子节点

                EquipType equipType = new EquipType();
                equipType.setEquipTypePid(id);
                equipType.setLabel(label);
                //字节点的sort都设置为最后的sort+1
                int maxSort = equipTypeMapper.maxEquipTypeSort();
                equipType.setEquipSort(maxSort + 1);
                int i = equipTypeMapper.insertSelective(equipType);
                if (i > 0) {
                    List<EquipType> newList = equipTypeMapper.selectChildEquipType(equipType.getEquipTypePid());
                    for (EquipType e : newList) {
                        if (e.getEquipTypeCode() != null) {
                            if (!e.getEquipTypeCode().equals("")) {
                                e.setLabel(e.getLabel() + "(" + e.getEquipTypeCode() + ")");
                            }
                        }
                    }
                    equipType.setName(label);
                    limsJson.setObject(equipType);
                    limsJson.setData(newList);
                    limsJson.setCode(0);
                    limsJson.setMsg("添加成功");
                }
            } else {//添加后叶子节点
                //以下的逻辑类似type=0,各种注释参考 type=0
                List<EquipType> list = equipTypeMapper.selectBySort(sort);
                EquipType equipType = new EquipType();
                equipType.setLabel(label);
                equipType.setEquipTypePid(pId);
                equipType.setEquipSort(sort + 1);//由于后面的更新是在插入后面做的，所以sort会自增1，这里不需要自增

                int i = equipTypeMapper.insertSelective(equipType);
                if (i > 0) {
                    for (EquipType e : list) {
                        if (e.getId() != null && e.getEquipSort() != null) {
                            if (e.getId().equals(id)) {
                                //查询出的list包括了这一条，但是添加是在他的后面添加，所以sort是从他后面开始添加的
                                //因此，这一条 数据的sort不改变
                                continue;
                            } else {
                                e.setEquipSort(e.getEquipSort() + 1);
                            }
                        }
                        equipTypeMapper.updateByPrimaryKeySelective(e);
                    }
                    List<EquipType> newList = equipTypeMapper.selectChildEquipType(pId);
                    for (EquipType e : newList) {
                        if (e.getEquipTypeCode() != null) {
                            if (!e.getEquipTypeCode().equals("")) {
                                e.setLabel(e.getLabel() + "(" + e.getEquipTypeCode() + ")");
                            }
                        }
                    }
                    equipType.setName(label);
                    limsJson.setObject(equipType);
                    limsJson.setData(newList);
                    limsJson.setCode(0);
                    limsJson.setMsg("添加成功");
                }

            }
        }else{
            limsJson.setMsg("空值无法添加");
        }
        return limsJson;
    }

    public Map<String,Object> addEquipTypeCapyByTypeId(String equuipTypeCapyIds,Integer equipTypeId){
        List list = new ArrayList();
        Map map = new HashMap();

        EquipType equipType = equipTypeMapper.selectByPrimaryKey(equipTypeId);
        equipType.setCapyIds(equuipTypeCapyIds);
        int i = equipTypeMapper.updateByPrimaryKeySelective(equipType);
        if(i>0){
            map.put("mes","添加成功");
            map.put("res",true);
        }else {
            map.put("mes","添加失败");
            map.put("res",false);
        }
        return map;
    }

    //传入一级设备类型菜单查询所有子菜单,并封装进去
    private DataTree findChilTree(EquipType pequipType){
        List secondList = new ArrayList();
        DataTree firstTree = new DataTree();
        DataTree chilTree=new DataTree();
        firstTree.setId(pequipType.getId());
        firstTree.setName(pequipType.getLabel());
        int caonParent = equipTypeMapper.contChild(pequipType.getId());
        if(caonParent>0) {//大于0表示有
            firstTree.setIsLeaf(false);
            List<EquipType> childEquipTypes = equipTypeMapper.selectChildEquipType(pequipType.getId());
            if(childEquipTypes.size()>0){
                for(EquipType firstChaild : childEquipTypes){
                    chilTree = findChilTree(firstChaild);
                    secondList.add(chilTree);
                }
            }
            firstTree.setChildren(secondList);
            return firstTree;
        }else{
            firstTree.setIsLeaf(true);
            return firstTree;
        }
    }
    public List selectTree(){
        List firstList = new ArrayList();
        List<EquipType> parentTypeList = equipTypeMapper.selectParentEquipType();
        if(parentTypeList.size()>0){
            for(EquipType pequipType :parentTypeList){
                DataTree chilTree = findChilTree(pequipType);
                firstList.add(chilTree);
            }
        }
        return firstList;
    }

    @Override
    public LimsJson updateCode(HttpServletRequest request,Integer equipTypeId,String code,Integer pId) {
        LimsJson limsJson=new LimsJson(1,"err");
        List<EquipType> parentEquipType = equipTypeMapper.selectParentEquipType();
        if(parentEquipType.size()>0) {
            for (EquipType equipTypeP : parentEquipType) {
                equipTypeP.setName(equipTypeP.getLabel());
                int caonParent = equipTypeMapper.contChild(equipTypeP.getId());//统计他的下面还有没有子集
                if (caonParent > 0) {
                    //cont》0说明有ziji
                    equipTypeP.setIsLeaf(false);
                }
                if (equipTypeP.getEquipTypeCode() != null) {
                    if (!equipTypeP.getEquipTypeCode().equals("")){
                        equipTypeP.setLabel(equipTypeP.getLabel() + "(" + equipTypeP.getEquipTypeCode() + ")");
                    }
                }
            }
        }
        limsJson.setData(parentEquipType);
        if(equipTypeId!=null&&code!=null){
            Map map=new HashMap();
            map.put("equipTypeCode",code);
            map.put("id",equipTypeId);
            if(code==""){
                int count = equipTypeMapper.updateCode(map);
                limsJson.setCode(0);
                limsJson.setMsg("操作成功");
                return  limsJson;
            }
            EquipType equipType=equipTypeMapper.selectTypename(map);
            if(equipType==null) {
                     equipTypeMapper.updateCode(map);
                    limsJson.setCode(0);
                    limsJson.setMsg("操作成功");
                }else{
                    limsJson.setCode(1);
                    limsJson.setMsg("请核实编码是否输入正确");
                }
            }else{
                limsJson.setCode(1);
                limsJson.setMsg("编码已存在");
            }
        return limsJson;
    }
    public LimsJson<EquipType> showEquipType(HttpServletRequest request, Integer equipTypeId,String typeCode) {
        LimsJson limsJson = new LimsJson(1,"err");

        try {
            EquipType equipType = equipTypeMapper.selectByPrimaryKey(equipTypeId);

            //客户要求设备得某个类型中原有得能力项不要清空，所以在这里返回原有得能力项。
            List  equipCapies = new ArrayList();
            String codes="";
            //设备类型中得能力项ids必须不为空，为空直接添加
            if (equipType.getCapyIds()!=null&&!equipType.getCapyIds().equals("")){
                String [] capyId = equipType.getCapyIds().split(",");
                Map map = new HashMap();

                for (int i=0;i<capyId.length;i++){
                    map.put("capyId",Integer.parseInt(capyId[i]));//根据设备能力项类型查询
                    EquipCapy equipCapy = equipCapyMapper.selCapyIdAndTypeCode(map);
                    if(equipCapy != null){
                        codes+=equipCapy.getTypeCode()+",";
                        equipCapies.add(equipCapy);
                    }

                }
            }
            String[] str=codes.split(",");
            List list=new ArrayList();
            for(int i=0;i<str.length;i++){
                if(!list.contains(str[i])){
                    list.add(str[i]);
                }
            }
            Map map = new HashMap();
            map.put("codes",list);
            List<LimsEquipCapyType> limsEquipCapyTypes = limsEquipCapyTypeMapper.typeInfo(map);
            List lists= new ArrayList();
            lists.add(limsEquipCapyTypes);
            lists.add(equipCapies);
            if(equipType.getId()!=null){
                limsJson.setCount(1);
                limsJson.setData(lists);
                limsJson.setMsg("data中返回得值是设备原来有的能力项，object中返回得值是设备类型");
                limsJson.setCode(0);
                limsJson.setObject(equipType);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        return limsJson;
    }

    @Override
    public LimsJson saveEquipType(String json, Integer pid) {
        LimsJson limsJson = new LimsJson(1, "err");                    //创建LimsJson工具对象
       /* JSONArray jsonarray = JSONArray.fromObject(json);                           //将json转换为对象
        List<EquipType> standTypeList = (List<EquipType>)JSONArray.toCollection(jsonarray, EquipType.class);*/
        if (pid == null) {
            pid = 0;
        }
        List list = new ArrayList();
        try {
            List<EquipType> standTypeList = JSONArray.parseArray(json, EquipType.class);
            if (standTypeList.size() > 0) {
                for (EquipType equipType : standTypeList) {
                    if (equipType.getId() != null && !StringUtils.checkNull(equipType.getLabel())) {
                       /* if (StringUtils.checkNull(equipType.getEquipTypeCode())) {
                            limsJson.setMsg("编码不能为空");
                            return limsJson;
                        }*/
                        if (equipType.getEquipSort() == null) {
                            limsJson.setMsg("序号不能为空");
                            return limsJson;
                        }
                        equipTypeMapper.updateByPrimaryKeySelective(equipType);
                        list.add(equipType);
                    } else if (equipType.getId() == null && !StringUtils.checkNull(equipType.getLabel())) {
                       /* if (StringUtils.checkNull(equipType.getEquipTypeCode())) {
                            limsJson.setMsg("编码不能为空");
                            return limsJson;
                        }*/
                        if (equipType.getEquipSort() == null) {
                            limsJson.setMsg("序号不能为空");
                            return limsJson;
                        }
                        equipType.setEquipTypePid(pid);
                        equipTypeMapper.insert(equipType);
                        list.add(equipType);
                    }
                }
                limsJson.setCode(0);
                limsJson.setMsg("修改成功!");
                limsJson.setData(list);
            } else {
                limsJson.setMsg("请填写数据!");
            }

        } catch (Exception e) {
            limsJson.setMsg("系統出錯,请联系管理员!");
            e.printStackTrace();
        }
        return limsJson;
    }
}
